home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / fab.py < prev    next >
Text File  |  2009-10-09  |  25KB  |  888 lines
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. #
  4. # (c) Copyright 2003-2009 Hewlett-Packard Development Company, L.P.
  5. #
  6. # This program is free software; you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation; either version 2 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program; if not, write to the Free Software
  18. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19. #
  20. # Author: Don Welch
  21. #
  22.  
  23. __version__ = '6.0'
  24. __title__ = "Fax Address Book"
  25. __mod__ = 'hp-fab'
  26. __doc__ = "A simple fax address book for HPLIP."
  27.  
  28. # Std Lib
  29. import cmd
  30. import getopt
  31. import os
  32.  
  33. # Local
  34. from base.g import *
  35. from base import utils, tui, module
  36.  
  37.  
  38. # Console class (from ASPN Python Cookbook)
  39. # Author:   James Thiele
  40. # Date:     27 April 2004
  41. # Version:  1.0
  42. # Location: http://www.eskimo.com/~jet/python/examples/cmd/
  43. # Copyright (c) 2004, James Thiele
  44. class Console(cmd.Cmd):
  45.  
  46.     def __init__(self):
  47.         cmd.Cmd.__init__(self)
  48.         self.intro  = "Type 'help' for a list of commands. Type 'exit' or 'quit' to quit."
  49.         self.db =  fax.FaxAddressBook() # database instance
  50.         self.prompt = log.bold("hp-fab > ")
  51.  
  52.     # Command definitions
  53.     def do_hist(self, args):
  54.         """Print a list of commands that have been entered"""
  55.         print self._hist
  56.  
  57.     def do_exit(self, args):
  58.         """Exits from the console"""
  59.         return -1
  60.  
  61.     def do_quit(self, args):
  62.         """Exits from the console"""
  63.         return -1
  64.  
  65.     # Command definitions to support Cmd object functionality
  66.     def do_EOF(self, args):
  67.         """Exit on system end of file character"""
  68.         return self.do_exit(args)
  69.  
  70.     def do_help(self, args):
  71.         """Get help on commands
  72.            'help' or '?' with no arguments prints a list of commands for which help is available
  73.            'help <command>' or '? <command>' gives help on <command>
  74.         """
  75.         # The only reason to define this method is for the help text in the doc string
  76.         cmd.Cmd.do_help(self, args)
  77.  
  78.     # Override methods in Cmd object
  79.     def preloop(self):
  80.         """Initialization before prompting user for commands.
  81.            Despite the claims in the Cmd documentaion, Cmd.preloop() is not a stub.
  82.         """
  83.         cmd.Cmd.preloop(self)   # sets up command completion
  84.         self._hist    = []      # No history yet
  85.         self._locals  = {}      # Initialize execution namespace for user
  86.         self._globals = {}
  87.  
  88.         self.do_list('')
  89.  
  90.     def postloop(self):
  91.         """Take care of any unfinished business.
  92.            Despite the claims in the Cmd documentaion, Cmd.postloop() is not a stub.
  93.         """
  94.         cmd.Cmd.postloop(self)   # Clean up command completion
  95.         print "Exiting..."
  96.  
  97.     def precmd(self, line):
  98.         """ This method is called after the line has been input but before
  99.             it has been interpreted. If you want to modifdy the input line
  100.             before execution (for example, variable substitution) do it here.
  101.         """
  102.         self._hist += [line.strip()]
  103.         return line
  104.  
  105.     def postcmd(self, stop, line):
  106.         """If you want to stop the console, return something that evaluates to true.
  107.            If you want to do some post command processing, do it here.
  108.         """
  109.         return stop
  110.  
  111.     def emptyline(self):
  112.         """Do nothing on empty input line"""
  113.         pass
  114.  
  115.     def default(self, line):
  116.         log.error("Unrecognized command. Use 'help' to list commands.")
  117.  
  118.     def get_nickname(self, args, fail_if_match=True, alt_text=False):
  119.         if not args:
  120.             while True:
  121.                 if alt_text:
  122.                     nickname = raw_input(log.bold("Enter the name to add to the group (<enter>=done*, c=cancel) ? ")).strip()
  123.                 else:
  124.                     nickname = raw_input(log.bold("Enter name (c=cancel) ? ")).strip()
  125.  
  126.                 if nickname.lower() == 'c':
  127.                     print log.red("Canceled")
  128.                     return ''
  129.  
  130.                 if not nickname:
  131.                     if alt_text:
  132.                         return ''
  133.                     else:
  134.                         log.error("Name must not be blank.")
  135.                         continue
  136.  
  137.  
  138.                 if fail_if_match:
  139.                     if self.db.get(nickname) is not None:
  140.                         log.error("Name already exists. Please choose a different name.")
  141.                         continue
  142.  
  143.                 else:
  144.                     if self.db.get(nickname) is None:
  145.                         log.error("Name not found. Please enter a different name.")
  146.                         continue
  147.  
  148.                 break
  149.  
  150.         else:
  151.             nickname = args.strip()
  152.  
  153.             if fail_if_match:
  154.                 if self.db.get(nickname) is not None:
  155.                     log.error("Name already exists. Please choose a different name.")
  156.                     return ''
  157.  
  158.             else:
  159.                 if self.db.get(nickname) is None:
  160.                     log.error("Name not found. Please enter a different name.")
  161.                     return ''
  162.  
  163.         return nickname
  164.  
  165.  
  166.     def get_groupname(self, args, fail_if_match=True, alt_text=False):
  167.         all_groups = self.db.get_all_groups()
  168.  
  169.         if not args:
  170.             while True:
  171.                 if alt_text:
  172.                     groupname = raw_input(log.bold("Enter the group to join (<enter>=done*, c=cancel) ? ")).strip()
  173.                 else:
  174.                     groupname = raw_input(log.bold("Enter the group (c=cancel) ? ")).strip()
  175.  
  176.  
  177.                 if groupname.lower() == 'c':
  178.                     print log.red("Canceled")
  179.                     return ''
  180.  
  181.                 if not groupname:
  182.                     if alt_text:
  183.                         return ''
  184.                     else:
  185.                         log.error("The group name must not be blank.")
  186.                         continue
  187.  
  188.                 if groupname == 'All':
  189.                     print "Cannot specify group 'All'. Please choose a different group."
  190.                     return ''
  191.  
  192.                 if fail_if_match:
  193.                     if groupname in all_groups:
  194.                         log.error("Group already exists. Please choose a different group.")
  195.                         continue
  196.  
  197.                 else:
  198.                     if groupname not in all_groups:
  199.                         log.error("Group not found. Please enter a different group.")
  200.                         continue
  201.  
  202.                 break
  203.  
  204.         else:
  205.             groupname = args.strip()
  206.  
  207.             if fail_if_match:
  208.                 if groupname in all_groups:
  209.                     log.error("Group already exists. Please choose a different group.")
  210.                     return ''
  211.  
  212.             else:
  213.                 if groupname not in all_groups:
  214.                     log.error("Group not found. Please enter a different group.")
  215.                     return ''
  216.  
  217.         return groupname
  218.  
  219.     def do_list(self, args):
  220.         """
  221.         List names and/or groups.
  222.         list [names|groups|all|]
  223.         dir [names|groups|all|]
  224.         """
  225.  
  226.         if args:
  227.             scope = args.strip().split()[0]
  228.  
  229.             if args.startswith('nam'):
  230.                 self.do_names('')
  231.                 return
  232.  
  233.             elif args.startswith('gro'):
  234.                 self.do_groups('')
  235.                 return
  236.  
  237.         self.do_names('')
  238.         self.do_groups('')
  239.  
  240.     do_dir = do_list
  241.  
  242.     def do_names(self, args):
  243.         """
  244.         List names.
  245.         names
  246.         """
  247.         all_entries = self.db.get_all_records()
  248.         log.debug(all_entries)
  249.  
  250.         print log.bold("\nNames:\n")
  251.         if len(all_entries) > 0:
  252.  
  253.             f = tui.Formatter()
  254.             f.header = ("Name", "Fax Number", "Notes", "Member of Group(s)")
  255.             for name, e in all_entries.items():
  256.                 if not name.startswith('__'):
  257.                     f.add((name, e['fax'], e['notes'], ', '.join(e['groups'])))
  258.  
  259.             f.output()
  260.  
  261.         else:
  262.             print "(None)"
  263.  
  264.         print
  265.  
  266.     def do_groups(self, args):
  267.         """
  268.         List groups.
  269.         groups
  270.         """
  271.         all_groups = self.db.get_all_groups()
  272.         log.debug(all_groups)
  273.  
  274.         print log.bold("\nGroups:\n")
  275.         if len(all_groups):
  276.  
  277.             f = tui.Formatter()
  278.             f.header = ("Group", "Members")
  279.             for group in all_groups:
  280.                 f.add((group, ', '.join([x for x in self.db.group_members(group) if not x.startswith('__')])))
  281.             f.output()
  282.  
  283.         else:
  284.             print "(None)"
  285.  
  286.         print
  287.  
  288.  
  289.     def do_edit(self, args):
  290.         """
  291.         Edit an name.
  292.         edit [name]
  293.         modify [name]
  294.         """
  295.         nickname = self.get_nickname(args, fail_if_match=False)
  296.         if not nickname: return
  297.  
  298.         e = self.db.get(nickname)
  299.         log.debug(e)
  300.  
  301.         print log.bold("\nEdit/modify information for %s:\n" % nickname)
  302.  
  303. #        save_title = e['title']
  304. #        title = raw_input(log.bold("Title (<enter>='%s', c=cancel) ? " % save_title)).strip()
  305. #
  306. #        if title.lower() == 'c':
  307. #            print log.red("Canceled")
  308. #            return
  309. #
  310. #        if not title:
  311. #            title = save_title
  312. #
  313. #        save_firstname = e['firstname']
  314. #        firstname = raw_input(log.bold("First name (<enter>='%s', c=cancel) ? " % save_firstname)).strip()
  315. #
  316. #        if firstname.lower() == 'c':
  317. #            print log.red("Canceled")
  318. #            return
  319. #
  320. #        if not firstname:
  321. #            firstname = save_firstname
  322. #
  323. #        save_lastname = e['lastname']
  324. #        lastname = raw_input(log.bold("Last name (<enter>='%s', c=cancel) ? " % save_lastname)).strip()
  325. #
  326. #        if lastname.lower() == 'c':
  327. #            print log.red("Canceled")
  328. #            return
  329. #
  330. #        if not lastname:
  331. #            lastname = save_lastname
  332.  
  333.         lastname = ''
  334.         firstname = ''
  335.         title = ''
  336.  
  337.         save_faxnum = e['fax']
  338.         while True:
  339.             faxnum = raw_input(log.bold("Fax Number (<enter>='%s', c=cancel) ? " % save_faxnum)).strip()
  340.  
  341.             if faxnum.lower() == 'c':
  342.                 print log.red("Canceled")
  343.                 return
  344.  
  345.             if not faxnum and not save_faxnum:
  346.                 log.error("Fax number must not be empty.")
  347.                 continue
  348.  
  349.             if not faxnum:
  350.                 faxnum = save_faxnum
  351.  
  352.             ok = True
  353.             for c in faxnum:
  354.                 if c not in '0123456789-(+) *#':
  355.                     log.error("Invalid characters in fax number. Fax number may only contain '0123456789-(+) '")
  356.                     ok = False
  357.                     break
  358.  
  359.  
  360.             if ok: break
  361.  
  362.         save_notes = e['notes']
  363.         notes = raw_input(log.bold("Notes (<enter>='%s', c=cancel) ? " % save_notes)).strip()
  364.  
  365.         if notes.lower() == 'c':
  366.             print log.red("Canceled")
  367.             return
  368.  
  369.         if not notes:
  370.             notes = save_notes
  371.  
  372.         if e['groups']:
  373.             print "\nLeave or Stay in a Group:\n"
  374.  
  375.         new_groups = []
  376.         for g in e['groups']:
  377.             if g == 'All':
  378.                 continue
  379.  
  380.             ok, ans = tui.enter_yes_no("Stay in group %s " % g,
  381.                 choice_prompt="(y=yes* (stay), n=no (leave), c=cancel) ? ")
  382.  
  383.             if not ok:
  384.                 print log.red("Canceled")
  385.                 return
  386.  
  387.             if ans:
  388.                 new_groups.append(g)
  389.  
  390.         print "\nJoin New Group(s):\n"
  391.  
  392.         while True:
  393.             add_group = self.get_groupname('', fail_if_match=False, alt_text=True)
  394.  
  395.             if add_group.lower() == 'c':
  396.                 print log.red("Canceled")
  397.                 return
  398.  
  399.             if not add_group:
  400.                 break
  401.  
  402.             all_groups = self.db.get_all_groups()
  403.  
  404.             if add_group not in all_groups:
  405.                 log.warn("Group not found.")
  406.                 ok, ans = tui.enter_yes_no("Is this a new group",
  407.                     choice_prompt="(y=yes* (new), n=no, c=cancel) ? ")
  408.  
  409.                 if not ok:
  410.                     print log.red("Canceled")
  411.                     return
  412.  
  413.                 if not ans:
  414.                     continue
  415.  
  416.             if add_group in e['groups']:
  417.                 log.error("Group already specified. Choose a different group name or press <enter> to continue.")
  418.                 continue
  419.  
  420.             new_groups.append(add_group)
  421.  
  422.         self.db.set(nickname, title, firstname, lastname, faxnum, new_groups, notes)
  423.         self.do_show(nickname)
  424.  
  425.         print
  426.  
  427.     do_modify = do_edit
  428.  
  429.  
  430.     def do_editgrp(self, args):
  431.         """
  432.         Edit a group.
  433.         editgrp [group]
  434.         modifygrp [group]
  435.         """
  436.         group = self.get_groupname(args, fail_if_match=False)
  437.         if not group: return
  438.  
  439.         old_entries = self.db.group_members(group)
  440.  
  441.         new_entries = []
  442.  
  443.         print "\nExisting Names in Group:\n"
  444.  
  445.         for e in old_entries:
  446.             if not e.startswith('__'):
  447.                 ok, ans = tui.enter_yes_no("Should '%s' stay in this group " % e,
  448.                     choice_prompt="(y=yes* (stay), n=no (leave), c=cancel) ? ")
  449.             else:
  450.                 continue
  451.  
  452.             if not ok:
  453.                 print log.red("Canceled")
  454.                 return
  455.  
  456.             if ans:
  457.                 new_entries.append(e)
  458.  
  459.         print "\nAdd New Names to Group:\n"
  460.  
  461.         while True:
  462.             nickname = self.get_nickname('', fail_if_match=False, alt_text=True)
  463.  
  464.             if nickname.lower() == 'c':
  465.                 print log.red("Canceled")
  466.                 return
  467.  
  468.             if not nickname.lower():
  469.                 break
  470.  
  471.             new_entries.append(nickname)
  472.  
  473.         self.db.update_groups(group, new_entries)
  474.  
  475.         print
  476.  
  477.     do_modifygrp = do_editgrp
  478.  
  479.  
  480.     def do_add(self, args):
  481.         """
  482.         Add an name.
  483.         add [name]
  484.         new [name]
  485.         """
  486.         nickname = self.get_nickname(args, fail_if_match=True)
  487.         if not nickname: return
  488.  
  489.         print log.bold("\nEnter information for %s:\n" % nickname)
  490.  
  491. #        title = raw_input(log.bold("Title (c=cancel) ? ")).strip()
  492. #
  493. #        if title.lower() == 'c':
  494. #            print log.red("Canceled")
  495. #            return
  496. #
  497. #        firstname = raw_input(log.bold("First name (c=cancel) ? ")).strip()
  498. #
  499. #        if firstname.lower() == 'c':
  500. #            print log.red("Canceled")
  501. #            return
  502. #
  503. #        lastname = raw_input(log.bold("Last name (c=cancel) ? ")).strip()
  504. #
  505. #        if lastname.lower() == 'c':
  506. #            print log.red("Canceled")
  507. #            return
  508.  
  509.         title = ''
  510.         firstname = ''
  511.         lastname = ''
  512.  
  513.         while True:
  514.             faxnum = raw_input(log.bold("Fax Number (c=cancel) ? ")).strip()
  515.  
  516.             if faxnum.lower() == 'c':
  517.                 print log.red("Canceled")
  518.                 return
  519.  
  520.             if not faxnum:
  521.                 log.error("Fax number must not be empty.")
  522.                 continue
  523.  
  524.             ok = True
  525.             for c in faxnum:
  526.                 if c not in '0123456789-(+) *#':
  527.                     log.error("Invalid characters in fax number. Fax number may only contain '0123456789-(+) *#'")
  528.                     ok = False
  529.                     break
  530.  
  531.  
  532.             if ok: break
  533.  
  534.         notes = raw_input(log.bold("Notes (c=cancel) ? ")).strip()
  535.  
  536.         if notes.strip().lower() == 'c':
  537.             print log.red("Canceled")
  538.             return
  539.  
  540.         groups = []
  541.         all_groups = self.db.get_all_groups()
  542.         while True:
  543.             add_group = raw_input(log.bold("Member of group (<enter>=done*, c=cancel) ? " )).strip()
  544.  
  545.             if add_group.lower() == 'c':
  546.                 print log.red("Canceled")
  547.                 return
  548.  
  549.             if not add_group:
  550.                 break
  551.  
  552.             if add_group == 'All':
  553.                 print log.red("Cannot specify 'All'.")
  554.                 continue
  555.  
  556.             if add_group not in all_groups:
  557.                 log.warn("Group not found.")
  558.  
  559.                 while True:
  560.                     user_input = raw_input(log.bold("Is this a new group (y=yes*, n=no) ? ")).lower().strip()
  561.  
  562.                     if user_input not in ['', 'n', 'y']:
  563.                         log.error("Please enter 'y', 'n' or press <enter> for 'yes'.")
  564.                         continue
  565.  
  566.                     break
  567.  
  568.                 if user_input == 'n':
  569.                     continue
  570.  
  571.             if add_group in groups:
  572.                 log.error("Group already specified. Choose a different group name or press <enter> to continue.")
  573.                 continue
  574.  
  575.             groups.append(add_group)
  576.  
  577.         groups.append('All')
  578.  
  579.         self.db.set(nickname, title, firstname, lastname, faxnum, groups, notes)
  580.         self.do_show(nickname)
  581.  
  582.  
  583.     do_new = do_add
  584.  
  585.  
  586.     def do_addgrp(self, args):
  587.         """
  588.         Add a group.
  589.         addgrp [group]
  590.         newgrp [group]
  591.         """
  592.         group = self.get_groupname(args, fail_if_match=True)
  593.         if not group: return
  594.  
  595.         entries = []
  596.         while True:
  597.             nickname = self.get_nickname('', fail_if_match=False, alt_text=True)
  598.  
  599.             if nickname.lower() == 'c':
  600.                 print log.red("Canceled")
  601.                 return
  602.  
  603.             if not nickname.lower():
  604.                 break
  605.  
  606.             entries.append(nickname)
  607.  
  608.         self.db.update_groups(group, entries)
  609.  
  610.         print
  611.  
  612.     do_newgrp = do_addgrp
  613.  
  614.  
  615.     def do_view(self, args):
  616.         """
  617.         View all name data.
  618.         view
  619.         """
  620.         all_entries = self.db.get_all_records()
  621.         log.debug(all_entries)
  622.  
  623.         print log.bold("\nView all Data:\n")
  624.         if len(all_entries) > 0:
  625.  
  626.             f = tui.Formatter()
  627.             f.header = ("Name", "Fax", "Notes", "Member of Group(s)")
  628.  
  629.             for name, e in all_entries.items():
  630.                 if not name.startswith('__'):
  631.                     f.add((name, e['fax'], e['notes'], ', '.join(e['groups'])))
  632.  
  633.             f.output()
  634.  
  635.         print
  636.  
  637.  
  638.  
  639.     def do_show(self, args):
  640.         """
  641.         Show a name (all details).
  642.         show [name]
  643.         details [name]
  644.         """
  645.         name = self.get_nickname(args, fail_if_match=False)
  646.         if not name: return
  647.  
  648.         e = self.db.get(name)
  649.         if e:
  650.             f = tui.Formatter()
  651.             f.header = ("Key", "Value")
  652.             f.add(("Name:", name))
  653.             #f.add(("Title:", e['title']))
  654.             #f.add(("First Name:", e['firstname']))
  655.             #f.add(("Last Name:", e['lastname']))
  656.             f.add(("Fax Number:", e['fax']))
  657.             f.add(("Notes:", e['notes']))
  658.             f.add(("Member of Group(s):", ', '.join(e['groups'])))
  659.  
  660.             f.output()
  661.  
  662.         else:
  663.             log.error("Name not found. Use the 'names' command to view all names.")
  664.  
  665.         print
  666.  
  667.     do_details = do_show
  668.  
  669.     def do_rm(self, args):
  670.         """
  671.         Remove a name.
  672.         rm [name]
  673.         del [name]
  674.         """
  675.         nickname = self.get_nickname(args, fail_if_match=False)
  676.         if not nickname: return
  677.  
  678.         self.db.delete(nickname)
  679.  
  680.         print
  681.  
  682.     do_del = do_rm
  683.  
  684.     def do_rmgrp(self, args):
  685.         """
  686.         Remove a group.
  687.         rmgrp [group]
  688.         delgrp [group]
  689.         """
  690.         group = self.get_groupname(args, fail_if_match=False)
  691.         if not group: return
  692.  
  693.         self.db.delete_group(group)
  694.  
  695.         print
  696.  
  697.     do_delgrp = do_rmgrp
  698.  
  699.  
  700.     def do_about(self, args):
  701.         """About fab."""
  702.         utils.log_title(__title__, __version__)
  703.  
  704.     def do_import(self, args):
  705.         """
  706.         Import LDIF
  707.         import <filename> [type]
  708.         [type] = vcf|ldif|auto
  709.         """
  710.         args = args.strip().split()
  711.  
  712.         if not args:
  713.             log.error("You must specify a filename to import from.")
  714.             return
  715.  
  716.         filename = args[0]
  717.  
  718.         if len(args) > 1:
  719.             typ = args[1].lower()
  720.         else:
  721.             typ = 'auto'
  722.  
  723.         if typ not in ('auto', 'ldif', 'vcf', 'vcard'):
  724.             log.error("Invalid type: %s" % typ)
  725.             return
  726.  
  727.         if not os.path.exists(filename):
  728.             log.error("File %s not found." % filename)
  729.             return
  730.  
  731.         if typ == 'auto':
  732.             ext = os.path.splitext(filename)[1].lower()
  733.             if ext == '.vcf':
  734.                 typ = 'vcf'
  735.             elif ext == '.ldif':
  736.                 typ = 'ldif'
  737.             else:
  738.                 head = file(filename, 'r').read(1024).lower()
  739.                 if 'begin:vcard' in head:
  740.                     typ = 'vcf'
  741.                 else:
  742.                     typ = 'ldif'
  743.  
  744.         if typ == 'ldif':
  745.             print "Importing from LDIF file %s..." % filename
  746.             ok, error_str = self.db.import_ldif(filename)
  747.  
  748.         elif typ in ('vcard', 'vcf'):
  749.             print "Importing from VCF file %s..." % filename
  750.             ok, error_str = self.db.import_vcard(filename)
  751.  
  752.         if not ok:
  753.             log.error(error_str)
  754.         else:
  755.             self.do_list('')
  756.  
  757.         print
  758.  
  759.  
  760.  
  761.  
  762. mod = module.Module(__mod__, __title__, __version__, __doc__, None,
  763.                     (GUI_MODE, INTERACTIVE_MODE),
  764.                     (UI_TOOLKIT_QT3, UI_TOOLKIT_QT4))
  765.  
  766. mod.setUsage(module.USAGE_FLAG_NONE)
  767.  
  768. opts, device_uri, printer_name, mode, ui_toolkit, loc = \
  769.     mod.parseStdOpts(handle_device_printer=False)
  770.  
  771. if ui_toolkit == 'qt3':
  772.     if not utils.canEnterGUIMode():
  773.         log.error("%s GUI mode requires GUI support (try running with --qt4). Entering interactive mode." % __mod__)
  774.         mode = INTERACTIVE_MODE
  775. else:
  776.     if not utils.canEnterGUIMode4():
  777.         log.error("%s GUI mode requires GUI support (try running with --qt3). Entering interactive mode." % __mod__)
  778.         mode = INTERACTIVE_MODE
  779.  
  780.  
  781. if mode == GUI_MODE:
  782.     if ui_toolkit == 'qt3':
  783.         log.set_module("hp-fab(qt3)")
  784.         try:
  785.             from qt import *
  786.             from ui.faxaddrbookform import FaxAddrBookForm
  787.         except ImportError:
  788.             log.error("Unable to load Qt3 support. Is it installed?")
  789.             sys.exit(1)
  790.  
  791.         app = None
  792.         addrbook = None
  793.         # create the main application object
  794.         app = QApplication(sys.argv)
  795.  
  796.         if loc is None:
  797.             loc = user_conf.get('ui', 'loc', 'system')
  798.             if loc.lower() == 'system':
  799.                 loc = str(QTextCodec.locale())
  800.                 log.debug("Using system locale: %s" % loc)
  801.  
  802.         if loc.lower() != 'c':
  803.             e = 'utf8'
  804.             try:
  805.                 l, x = loc.split('.')
  806.                 loc = '.'.join([l, e])
  807.             except ValueError:
  808.                 l = loc
  809.                 loc = '.'.join([loc, e])
  810.  
  811.             log.debug("Trying to load .qm file for %s locale." % loc)
  812.             trans = QTranslator(None)
  813.  
  814.             qm_file = 'hplip_%s.qm' % l
  815.             log.debug("Name of .qm file: %s" % qm_file)
  816.             loaded = trans.load(qm_file, prop.localization_dir)
  817.  
  818.             if loaded:
  819.                 app.installTranslator(trans)
  820.             else:
  821.                 loc = 'c'
  822.  
  823.         if loc == 'c':
  824.             log.debug("Using default 'C' locale")
  825.         else:
  826.             log.debug("Using locale: %s" % loc)
  827.             QLocale.setDefault(QLocale(loc))
  828.             prop.locale = loc
  829.             try:
  830.                 locale.setlocale(locale.LC_ALL, locale.normalize(loc))
  831.             except locale.Error:
  832.                 pass
  833.  
  834.         addrbook = FaxAddrBookForm()
  835.         addrbook.show()
  836.         app.setMainWidget(addrbook)
  837.  
  838.         try:
  839.             log.debug("Starting GUI loop...")
  840.             app.exec_loop()
  841.         except KeyboardInterrupt:
  842.             pass
  843.  
  844.         sys.exit(0)
  845.  
  846.     else: # qt4
  847.         try:
  848.             from PyQt4.QtGui import QApplication
  849.             from ui4.fabwindow import FABWindow
  850.         except ImportError:
  851.             log.error("Unable to load Qt4 support. Is it installed?")
  852.             sys.exit(1)
  853.  
  854.         log.set_module("hp-fab(qt4)")
  855.  
  856.         if 1:
  857.             app = QApplication(sys.argv)
  858.  
  859.             fab = FABWindow(None)
  860.             fab.show()
  861.  
  862.             try:
  863.                 log.debug("Starting GUI loop...")
  864.                 app.exec_()
  865.             except KeyboardInterrupt:
  866.                 sys.exit(0)
  867.  
  868.  
  869.  
  870. else: # INTERACTIVE_MODE
  871.     try:
  872.         from fax import fax
  873.     except ImportError:
  874.         # This can fail on Python < 2.3 due to the datetime module
  875.         log.error("Fax address book disabled - Python 2.3+ required.")
  876.         sys.exit(1)
  877.  
  878.     console = Console()
  879.  
  880.     try:
  881.         console.cmdloop()
  882.     except KeyboardInterrupt:
  883.         log.error("User exit.")
  884.  
  885.     log.info("")
  886.     log.info("Done.")
  887.  
  888.